#include <iostream>
#include <queue>
#include <unistd.h>
#include <cstdlib>
#include <pthread.h>
#include <mutex>
using namespace std;


const uint32_t gDefaultCap = 5;

template<class T>
class BlockQueue
{
public:
    BlockQueue(uint32_t cap = gDefaultCap) 
        :cap_(cap)
    {
        pthread_mutex_init(&mutex_,nullptr);
        pthread_cond_init(&concond_,nullptr);
        pthread_cond_init(&procond_,nullptr);
    }

    ~BlockQueue()
    {
        pthread_mutex_destroy(&mutex_);
        pthread_cond_destroy(&concond_);
        pthread_cond_destroy(&procond_);
    }
public:
    //生产接口
    void push(const T& in)
    {
        lockQueue();
    }

    //消费接口
    void pop()
    {

    }
private:
    void lockQueue()
    {
        pthread_mutex_lock(&mutex_);
    }
    void unlockQueue()
    {
        pthread_mutex_unlock(&mutex_);
    }

    bool isEmpty()
    {
        return bq_.empty();
    }
    bool isFull()
    {
        return bq_.size() == cap_;
    }

    void proBlockWait()
    {
        //生产者一定在临界区中
        //1.在阻塞线程的时候，会自动释放mutex_锁
        pthread_cond_wait(&procond_,&mutex_);
    }

    void conBlackWait()
    {
        //阻塞等待  等待被唤醒
        pthread_cond_wait(&concode)
    }

private:
    queue<T> bq_;//blockqueue
    uint32_t cap_;//容量
    pthread_mutex_t mutex_;//保护阻塞队列的互斥锁
    //只有互斥锁可能导致饥饿问题
    pthread_cond_t concond_;//让消费者等待的条件变量
    pthread_cond_t procond_;//让生产者等待的条件变量

};

int main()
{
    //定义一个阻塞队列
    //创建两个线程 一个生产者 一个消费者
    return 0;
}
